package stream02;

import org.junit.Test;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Stream流的最终操作:
 *   1.迭代
 *     forEach:逐个消费流中的元素
 *   2.统计
 *     count:统计流中元素的个数
 *     max:按照一定比较规则(Comparator接口实现的规则),来获取流中最大元素
 *     min:按照一定比较规则(Comparator接口实现的规则),来获取流中最小元素
 *   3.查找
 *     findFirst
 *   4.匹配
 *     allMatch:只有流中所有的元素都满足传入Predicate(条件),allMatch方法才返回true,否则返回false
 *     anyMatch:只要有一个元素满足传入Predicate(条件),anyMatch方法返回true,否则返回false
 *     noneMatch:只有流中所有的元素都不满足传入Predicate(条件),noneMath方法才返回true,否则返回false
 *   5.收集
 *     collect:我们可以将最终操作结果收集到一个集合(List,Set,Map)中
 *             我们主要通过Collectors.toList(),Collectors.toSet(),Collectors.toMap,将最终操作结果收集到不同集合中
 * 中间操作:
 *   sorted:按照一定比较规则(Comparator接口实现的规则),从小到大排序
 */
public class StreamDemo03 {
	List<String> list = Arrays.asList("zhangsan", "lisi", "laowang");

	@Test
	public void test01() {
		list.stream().forEach(System.out::println);
	}

	@Test
	public void test02() {
		long count = list.stream().count();
		System.out.println(count);
	}

	@Test
	public void test03() {
        list.stream().sorted().forEach(System.out::println);//字符串的默认排序方式是字典顺序
		System.out.println("----------------------------");
		/**
		 * Comparator接口的
		 *   int compare(T o1, T o2)
		 *    如果compare方法返回一个正数,就认为 o1>o2
		 *    如果compare方法返回一个负数,就认为 o1<o2
		 *    如果compare方法返回0,就认为o1=o2
		 *  sorted方法默认按照元素从小到大排序
		 * 比较流程:
		 * str1="lisi"
		 * str2="zhangsan"
		 * str1.length()-str2.length()<0 => "lisi"<"zhangsan"
		 * 第二种情况: str2.length()-str1.length()>0 => "lisi" > "zhangsan"
		 *
		 * str1="laowang"
		 * str2="zhangsan"
		 * str1.length()-str2.length()<0 => "laowang"<"zhangsan"
		 * 第二种情况: str2.length()-str1.length()>0 => "laowang" > "zhangsan"
		 *
		 * str1="laowang"
		 * str2="lisi"
		 * str1.length()-str2.length()>0 => "laowang" > "lisi"
		 *第二种情况: str2.length()-str1.length()<0 => "laowang"< "lisi"
		 *
		 * 最终结果: lisi<laowang<zhangsan
		 * 第二种情况最终结果: zhangsan<laowang<lisi
		 */
		list.stream().sorted((str1,str2)->str1.length()-str2.length()).forEach(System.out::println);
		System.out.println("---------------------");
		list.stream().sorted((str1,str2)->str2.length()-str1.length()).forEach(System.out::println);
	}

	//List<String> list = Arrays.asList("zhangsan", "lisi", "laowang");
	@Test
	public void test04() {
		//获取最大长度字符串
		System.out.println(list.stream().max((str1, str2) -> str1.length() - str2.length()).get());

		//获取最小长度字符串
		System.out.println(list.stream().min((str1, str2) -> str1.length() - str2.length()).get());
	}

	@Test
	public void test05() {
		String str = list.stream().findFirst().get();
		System.out.println(str);
	}

	@Test
	public void test06() {
		System.out.println(list.stream().allMatch(str -> str.length() > 4));//false
		System.out.println(list.stream().anyMatch(str -> str.length() > 4));//true
		System.out.println(list.stream().noneMatch(str -> str.length() > 4));//false
	}

	@Test
	public void test07() {
		Stream<String> stream = list.stream();
		List<String> l = stream.collect(Collectors.toList());//将流中的数据收集到一个List集合中
		System.out.println(l.getClass());
		System.out.println(l.size());
	}

	@Test
	public void test08() {
		Set<String> set = list.stream().collect(Collectors.toSet());
		System.out.println(set);
	}

	@Test
	public void test09() {
		//将字符串的长度作为key,字符串的值作为value去构造一个map
		Map<Integer, String> map = list.stream().collect(Collectors.toMap(str -> str.length(), str -> str));
		System.out.println(map);
	}
}
